// API 配置和请求封装
const API_BASE_URL = 'http://localhost:8080/api/v1';
const API_PUBLIC_URL = 'http://localhost:8080/api/v1/public';

// 检测运行环境
const isWailsApp = typeof window !== 'undefined' && window.go !== undefined;
const isDesktop = isWailsApp;

// Wails API 桥接
let wailsAPI = null;
if (isWailsApp) {
    wailsAPI = window.go.main.App;
}

// 全局错误处理
window.addEventListener('unhandledrejection', function(event) {
    console.error('未处理的Promise拒绝:', event.reason);
    if (typeof showAlert === 'function') {
        showAlert('系统错误: ' + (event.reason.message || '未知错误'), 'error');
    }
    event.preventDefault();
});

window.addEventListener('error', function(event) {
    console.error('全局JavaScript错误:', event.error);
    if (typeof showAlert === 'function') {
        showAlert('脚本错误: ' + (event.error.message || '未知错误'), 'error');
    }
});

// 获取存储的token
function getToken() {
    return localStorage.getItem('goldtree_token');
}

// 设置token
function setToken(token) {
    localStorage.setItem('goldtree_token', token);
}

// 移除token
function removeToken() {
    localStorage.removeItem('goldtree_token');
}

// 通用请求封装
async function apiRequest(url, options = {}) {
    const token = getToken();
    const defaultOptions = {
        headers: {
            'Content-Type': 'application/json',
            ...(token && { 'Authorization': `Bearer ${token}` })
        }
    };

    const finalOptions = {
        ...defaultOptions,
        ...options,
        headers: {
            ...defaultOptions.headers,
            ...options.headers
        }
    };

    try {
        console.log('发起API请求:', url, finalOptions);
        const response = await fetch(url, finalOptions);
        const data = await response.json();
        
        console.log('API响应:', response.status, data);
        
        // 处理401未授权错误
        if (response.status === 401) {
            removeToken();
            if (typeof showLoginModal === 'function') {
                showLoginModal();
            } else {
                console.warn('showLoginModal 函数未定义，将在页面加载后重试');
                // 延迟执行，等待main.js加载完成
                setTimeout(() => {
                    if (typeof showLoginModal === 'function') {
                        showLoginModal();
                    } else {
                        location.reload(); // 如果仍然未定义，刷新页面
                    }
                }, 100);
            }
            throw new Error('登录已过期，请重新登录');
        }
        
        if (!response.ok) {
            throw new Error(data.message || `HTTP ${response.status}: 请求失败`);
        }
        
        return data;
    } catch (error) {
        console.error('API请求错误:', error);
        // 如果是网络错误，提供更友好的错误信息
        if (error instanceof TypeError && error.message.includes('fetch')) {
            throw new Error('网络连接失败，请检查网络或服务器状态');
        }
        throw error;
    }
}

// GET请求
async function apiGet(endpoint) {
    return apiRequest(`${API_BASE_URL}${endpoint}`);
}

// POST请求
async function apiPost(endpoint, data) {
    return apiRequest(`${API_BASE_URL}${endpoint}`, {
        method: 'POST',
        body: JSON.stringify(data)
    });
}

// PUT请求
async function apiPut(endpoint, data) {
    return apiRequest(`${API_BASE_URL}${endpoint}`, {
        method: 'PUT',
        body: JSON.stringify(data)
    });
}

// DELETE请求
async function apiDelete(endpoint) {
    return apiRequest(`${API_BASE_URL}${endpoint}`, {
        method: 'DELETE'
    });
}

// 公开API请求
async function apiPublic(endpoint, data, method = 'POST') {
    return apiRequest(`${API_PUBLIC_URL}${endpoint}`, {
        method,
        body: data ? JSON.stringify(data) : undefined
    });
}

// 用户登录
async function login(username, password) {
    if (isWailsApp) {
        // 桌面环境使用 Wails API
        try {
            const result = await wailsAPI.UserLogin(username, password);
            console.log('桌面登录结果:', result);
            return result;
        } catch (error) {
            console.error('桌面登录失败:', error);
            throw error;
        }
    } else {
        // Web环境使用 HTTP API
        return apiPublic('/auth/login', { username, password });
    }
}

// 获取股票列表
async function getStocks(params = {}) {
    if (isWailsApp) {
        // 桌面环境使用 Wails API
        try {
            const result = await wailsAPI.StockGetList(params);
            console.log('桌面获取股票列表结果:', result);
            return result;
        } catch (error) {
            console.error('桌面获取股票列表失败:', error);
            throw error;
        }
    } else {
        // Web环境使用 HTTP API
        const queryParams = new URLSearchParams();
        
        if (params.page) queryParams.append('page', params.page);
        if (params.limit) queryParams.append('limit', params.limit);
        if (params.keyword) queryParams.append('keyword', params.keyword);
        if (params.market) queryParams.append('market', params.market);
        if (params.industry) queryParams.append('industry', params.industry);
        if (params.sector) queryParams.append('sector', params.sector);
        if (params.is_active !== undefined) queryParams.append('is_active', params.is_active);
        if (params.min_market_cap) queryParams.append('min_market_cap', params.min_market_cap);
        if (params.max_market_cap) queryParams.append('max_market_cap', params.max_market_cap);
        if (params.min_pe_ratio) queryParams.append('min_pe_ratio', params.min_pe_ratio);
        if (params.max_pe_ratio) queryParams.append('max_pe_ratio', params.max_pe_ratio);
        if (params.sort_by) queryParams.append('sort_by', params.sort_by);
        if (params.sort_order) queryParams.append('sort_order', params.sort_order);
        
        return apiGet(`/stocks?${queryParams}`);
    }
}

// 创建股票
async function createStock(stockData) {
    console.log('调用createStock API，参数:', stockData);
    if (isWailsApp) {
        // 桌面环境使用 Wails API
        try {
            const result = await wailsAPI.StockCreate(stockData);
            console.log('桌面创建股票结果:', result);
            return result;
        } catch (error) {
            console.error('桌面创建股票失败:', error);
            throw error;
        }
    } else {
        // Web环境使用 HTTP API
        const result = await apiPost('/stocks', stockData);
        console.log('createStock API返回结果:', result);
        return result;
    }
}

// 更新股票
async function updateStock(id, stockData) {
    return apiPut(`/stocks/${id}`, stockData);
}

// 删除股票
async function deleteStock(id) {
    return apiDelete(`/stocks/${id}`);
}

// 获取股票详情
async function getStockById(id) {
    return apiGet(`/stocks/${id}`);
}

// 根据代码获取股票
async function getStockByCode(code) {
    return apiGet(`/stocks/code/${code}`);
}

// 批量创建股票
async function batchCreateStocks(stocks) {
    return apiPost('/stocks/batch', stocks);
}

// 导入股票数据
async function importStocks(importData) {
    if (isWailsApp) {
        // 桌面环境使用 Wails API
        try {
            const result = await wailsAPI.StockImport(importData);
            console.log('桌面导入股票结果:', result);
            return result;
        } catch (error) {
            console.error('桌面导入股票失败:', error);
            throw error;
        }
    } else {
        // Web环境使用 HTTP API
        return apiPost('/stocks/import', importData);
    }
}

// 验证股票数据
async function validateStock(stockData) {
    return apiPost('/stocks/validate', stockData);
}

// 批量更新股票状态
async function bulkUpdateStockStatus(codes, isActive) {
    return apiPost('/stocks/bulk-status', { codes, is_active: isActive });
}

// 同步市场数据
async function syncMarketData() {
    return apiPost('/stocks/sync');
}

// 获取行业列表
async function getIndustries() {
    if (isWailsApp) {
        // 桌面环境使用 Wails API
        try {
            const result = await wailsAPI.StockGetIndustries();
            console.log('桌面获取行业列表结果:', result);
            return result;
        } catch (error) {
            console.error('桌面获取行业列表失败:', error);
            throw error;
        }
    } else {
        // Web环境使用 HTTP API
        return apiGet('/stocks/industries');
    }
}

// 获取板块列表
async function getSectors() {
    return apiGet('/stocks/sectors');
}

// 获取市场列表
async function getMarkets() {
    return apiGet('/stocks/markets');
}

// 获取股票统计信息
async function getStockStatistics() {
    return apiGet('/stocks/statistics');
}

// 获取股票池列表
async function getPools(page = 1, limit = 20) {
    const params = new URLSearchParams({ page, limit });
    return apiGet(`/stock-pools?${params}`);
}

// 创建股票池
async function createPool(poolData) {
    return apiPost('/stock-pools', poolData);
}

// 获取标签列表
async function getTags(page = 1, limit = 20) {
    const params = new URLSearchParams({ page, limit });
    return apiGet(`/tags?${params}`);
}

// 创建标签
async function createTag(tagData) {
    return apiPost('/tags', tagData);
}

// 获取策略列表
async function getStrategies(page = 1, limit = 20) {
    const params = new URLSearchParams({ page, limit });
    return apiGet(`/strategies?${params}`);
}

// 创建策略
async function createStrategy(strategyData) {
    return apiPost('/strategies', strategyData);
}

// 启动策略
async function startStrategy(id) {
    return apiPost(`/strategies/${id}/start`);
}

// 停止策略
async function stopStrategy(id) {
    return apiPost(`/strategies/${id}/stop`);
}

// 获取数据统计
async function getStatistics() {
    if (isWailsApp) {
        // 桌面环境使用 Wails API
        try {
            const result = await wailsAPI.GetSystemStats();
            console.log('桌面获取统计数据结果:', result);
            return result;
        } catch (error) {
            console.error('桌面获取统计数据失败:', error);
            throw error;
        }
    } else {
        // Web环境使用 HTTP API
        return apiGet('/data/statistics');
    }
}

// 检测运行环境
function getAppMode() {
    return isWailsApp ? 'desktop' : 'web';
}

// 桌面应用特有功能
function showDesktopNotification(title, message) {
    if (isWailsApp && wailsAPI) {
        wailsAPI.ShowNotification(title, message);
    } else {
        console.log('通知:', title, '-', message);
    }
}

// 获取应用信息
async function getAppInfo() {
    if (isWailsApp && wailsAPI) {
        return await wailsAPI.GetAppInfo();
    }
    return {
        name: 'GoldTree',
        version: '1.0.0',
        description: '股票量化交易管理系统',
        mode: 'web'
    };
}